// pages/timer/timer.js
import CommandManager from '../../utils/commandManager';
import sharedUdpManagerModule from '../../utils/sharedUdpManager';

const sharedUdpManager = sharedUdpManagerModule.instance;

Page({

  /**
   * 页面的初始数据
   */
  data: {
    timerList: [],
    loading: false
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 尝试从事件通道获取连接状态
    const eventChannel = this.getOpenerEventChannel();
    eventChannel.on('deviceConnected', (data) => {
      console.log('[定时] 收到设备连接状态:', data);
      if (data.isConnected && data.udpManager) {
        // 初始化共享实例
        sharedUdpManagerModule.initialize(data.udpManager);
        
        // 保存 udpManager 到 globalData
        getApp().globalData.udpManager = data.udpManager;
        
        // 获取定时列表
        this.getTimerList();
      }
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 每次显示页面时刷新定时列表
    this.getTimerList();
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    const app = getApp();
    const udpManager = app.globalData?.udpManager;
    if (udpManager) {
      // 清理所有该页面注册的消息处理器
      udpManager.messageHandlers.clear();
      
      // 通知上一页面
      const eventChannel = this.getOpenerEventChannel();
      if (eventChannel && eventChannel.emit) {
        eventChannel.emit('returnFromTimer');
      }
    }
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  // 获取定时列表
  getTimerList() {
    // 优先从全局获取
    const app = getApp();
    const globalUdpManager = app.globalData?.udpManager;
    
    // 然后尝试共享实例
    const moduleAvailable = typeof sharedUdpManagerModule.isInitialized === 'function';
    const isSharedAvailable = moduleAvailable && sharedUdpManagerModule.isInitialized();
    
    // 最后检查局部变量
    if (!globalUdpManager && !isSharedAvailable) {
      console.error('[定时] udpManager 未初始化或未连接');
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      return;
    }
    
    // 选择可用的 udpManager
    const udpManager = globalUdpManager || sharedUdpManager;
    
    this.setData({ loading: true });
    
    // 创建消息处理器
    const messageHandler = (data) => {
      const result = CommandManager.parseFrame(data);
      if (result && result.cmd === CommandManager.Commands.QUERY_TIMER.CMD) {
        console.log('[定时] 收到定时列表:', result.data);
        
        // 将定时列表转换为页面需要的格式
        const formattedList = result.data.timers.map((timer, index) => {
          // 格式化开始时间
          const startTime = `${String(timer.hour).padStart(2, '0')}:${String(timer.minute).padStart(2, '0')}`;
          
          // 格式化结束时间(如果是时间段类型)
          const endTime = timer.type === 3 ? 
            `${String(timer.endHour).padStart(2, '0')}:${String(timer.endMinute).padStart(2, '0')}` : '';
          
          return {
            id: index + 1,
            time: startTime,
            endTime: endTime,
            repeat: this.getRepeatText(timer),
            enabled: timer.enabled,
            action: timer.action === 0 ? 'on' : 'off',
            x: 0,
            // 保存原始数据
            rawData: timer
          };
        });
        
        this.setData({
          timerList: formattedList,
          loading: false
        });
      }
    };
    
    // 注册消息处理器并发送命令
    udpManager.onMessage(messageHandler);
    
    // 创建查询命令
    const frame = CommandManager.createCommand('QUERY_TIMER');
    if (!frame) {
      console.error('[定时] 创建查询命令失败');
      wx.showToast({
        title: '创建命令失败',
        icon: 'none'
      });
      this.setData({ loading: false });
      udpManager.offMessage(messageHandler);
      return;
    }
    
    // 发送查询命令
    udpManager.send(frame)
      .then(() => {
        console.log('[定时] 已发送查询命令');
        // 注意：不在这里设置 loading: false，因为需要等待响应
        
        // 设置超时处理
        setTimeout(() => {
          if (this.data.loading) {
            console.log('[定时] 查询超时');
            this.setData({ loading: false });
            udpManager.offMessage(messageHandler);
            wx.showToast({
              title: '查询超时',
              icon: 'none'
            });
          }
        }, 2000);
      })
      .catch(err => {
        console.error('[定时] 查询失败:', err);
        wx.showToast({
          title: '获取定时列表失败',
          icon: 'none'
        });
        this.setData({ loading: false });
        udpManager.offMessage(messageHandler);
      });
  },

  // 获取重复文本
  getRepeatText(timer) {
    const { type, dayMask } = timer;
    
    switch (type) {
      case 0: // 单次
        return '单次';
      case 1: // 每天
        return '每天';
      case 2: // 每周
        if (dayMask === 0x7F) return '每天';
        
        const days = [];
        const weekdays = ['一', '二', '三', '四', '五', '六', '日'];
        for (let i = 0; i < 7; i++) {
          if (dayMask & (1 << i)) {
            days.push(weekdays[i]);
          }
        }
        return days.length > 0 ? `每周${days.join('、')}` : '未设置';
        
      case 3: // 时间段
        return '时间段';
      default:
        return '未知';
    }
  },

  // 切换定时启用状态
  toggleTimer(e) {
    const timerId = e.currentTarget.dataset.id;
    const enabled = e.detail.value;
    
    // 查找当前操作的定时器索引
    const index = this.data.timerList.findIndex(item => item.id === timerId);
    
    if (index === -1) {
      wx.showToast({
        title: '定时器不存在',
        icon: 'none'
      });
      return;
    }
    
    // 获取定时器对象
    const timer = this.data.timerList[index];
    
    // 显示加载状态
    wx.showLoading({
      title: enabled ? '正在启用...' : '正在禁用...',
      mask: true
    });
    
    // 准备更新数据
    const updateData = {
      timerId: timerId,
      ...timer.rawData,  // 复制原始数据
      enabled: enabled   // 修改启用状态
    };
    
    // 创建更新命令
    const app = getApp();
    const udpManager = app.globalData?.udpManager || sharedUdpManager;
    
    if (!udpManager || !udpManager.isConnected) {
      wx.hideLoading();
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      
      // 恢复开关状态
      setTimeout(() => {
        const timerList = [...this.data.timerList];
        timerList[index].enabled = !enabled;
        this.setData({ timerList });
      }, 200);
      return;
    }
    
    // 创建更新命令
    const frame = CommandManager.createCommand('UPDATE_TIMER', updateData);
    
    if (!frame) {
      wx.hideLoading();
      wx.showToast({
        title: '创建命令失败',
        icon: 'none'
      });
      
      // 恢复开关状态
      setTimeout(() => {
        const timerList = [...this.data.timerList];
        timerList[index].enabled = !enabled;
        this.setData({ timerList });
      }, 200);
      return;
    }
    
    // 创建响应处理器
    const messageHandler = (data) => {
      const result = CommandManager.parseFrame(data);
      if (result && result.cmd === CommandManager.Commands.UPDATE_TIMER.CMD) {
        wx.hideLoading();
        
        if (result.data.success) {
          // 更新成功
          wx.showToast({
            title: enabled ? '已启用' : '已禁用',
            icon: 'success'
          });
          
          // 更新本地状态
          const timerList = [...this.data.timerList];
          timerList[index].enabled = enabled;
          this.setData({ timerList });
        } else {
          // 更新失败
          wx.showToast({
            title: '更新失败',
            icon: 'none'
          });
          
          // 恢复开关状态
          setTimeout(() => {
            const timerList = [...this.data.timerList];
            timerList[index].enabled = !enabled;
            this.setData({ timerList });
          }, 200);
        }
        
        // 移除消息处理器
        udpManager.offMessage(messageHandler);
      }
    };
    
    // 注册消息处理器
    udpManager.onMessage(messageHandler);
    
    // 发送命令
    udpManager.send(frame)
      .then(() => {
        console.log('[定时] 更新命令已发送:', enabled ? '启用' : '禁用');
        
        // 设置超时
        setTimeout(() => {
          // 检查是否已经处理了响应
          const currentEnabled = this.data.timerList[index].enabled;
          if (currentEnabled !== enabled) {
            wx.hideLoading();
            udpManager.offMessage(messageHandler);
            wx.showToast({
              title: '操作超时',
              icon: 'none'
            });
            
            // 恢复开关状态
            const timerList = [...this.data.timerList];
            timerList[index].enabled = !enabled;
            this.setData({ timerList });
          }
        }, 5000);
      })
      .catch(err => {
        console.error('[定时] 发送失败:', err);
        wx.hideLoading();
        udpManager.offMessage(messageHandler);
        wx.showToast({
          title: '发送失败',
          icon: 'none'
        });
        
        // 恢复开关状态
        setTimeout(() => {
          const timerList = [...this.data.timerList];
          timerList[index].enabled = !enabled;
          this.setData({ timerList });
        }, 200);
      });
  },

  // 显示添加定时面板
  showAddTimer() {
    // 检查设备是否连接
    const app = getApp();
    const udpManager = app.globalData?.udpManager || sharedUdpManager;
    
    if (!udpManager || !udpManager.isConnected) {
      wx.showToast({
        title: '请先连接设备',
        icon: 'none'
      });
      return;
    }
    
    // 添加跳转前的日志
    console.log('[定时] 跳转到添加定时页面');
    
    // 跳转到添加定时页面
    wx.navigateTo({
      url: '/pages/timer/add/add',
      success: function(res) {
        console.log('[定时] 跳转成功');
        // 传递UDP管理器
        res.eventChannel.emit('setUDPManager', {
          udpManager: udpManager
        });
      },
      fail: function(err) {
        console.error('[定时] 跳转失败:', err);
        wx.showToast({
          title: '跳转失败：' + err.errMsg,
          icon: 'none'
        });
      }
    });
  },

  // 添加定时
  addTimer(config) {
    const app = getApp();
    const udpManager = app.globalData?.udpManager || sharedUdpManager;
    
    if (!udpManager || !udpManager.isConnected) {
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      return Promise.reject(new Error('设备未连接'));
    }

    const frame = CommandManager.createCommand('ADD_TIMER', config);
    return udpManager.send(frame);
  },

  // 删除定时
  deleteTimer(e) {
    const timerId = e.currentTarget.dataset.id;
    const index = this.data.timerList.findIndex(item => item.id === timerId);
    
    if (index === -1) return;
    
    wx.showModal({
      title: '删除定时',
      content: '确定要删除这个定时吗？',
      success: (res) => {
        if (res.confirm) {
          // 执行删除操作
          this.executeDeleteTimer(timerId, index);
        } else {
          // 取消删除，恢复原位
          const timerList = this.data.timerList;
          timerList[index].x = 0;
          this.setData({ timerList });
        }
      }
    });
  },

  // 执行删除定时器操作
  executeDeleteTimer(timerId, index) {
    const app = getApp();
    const udpManager = app.globalData?.udpManager || sharedUdpManager;
    
    if (!udpManager || !udpManager.isConnected) {
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      return;
    }
    
    wx.showLoading({
      title: '正在删除...'
    });
    
    // 创建删除命令
    const frame = CommandManager.createCommand('DELETE_TIMER', timerId);
    
    if (!frame) {
      wx.hideLoading();
      wx.showToast({
        title: '创建命令失败',
        icon: 'none'
      });
      return;
    }
    
    // 创建响应处理器
    const messageHandler = (data) => {
      const result = CommandManager.parseFrame(data);
      if (result && result.cmd === CommandManager.Commands.DELETE_TIMER.CMD) {
        wx.hideLoading();
        
        if (result.data.success) {
          // 从列表中移除
          const timerList = this.data.timerList;
          timerList.splice(index, 1);
          this.setData({ timerList });
          
          wx.showToast({
            title: '删除成功',
            icon: 'success'
          });
        } else {
          wx.showToast({
            title: '删除失败',
            icon: 'none'
          });
        }
        
        // 移除处理器
        udpManager.offMessage(messageHandler);
      }
    };
    
    // 注册消息处理器
    udpManager.onMessage(messageHandler);
    
    // 发送命令
    udpManager.send(frame)
      .then(() => {
        console.log('[定时] 删除命令已发送');
        
        // 设置超时
        setTimeout(() => {
          if (this.data.timerList[index]) {
            wx.hideLoading();
            udpManager.offMessage(messageHandler);
            wx.showToast({
              title: '操作超时',
              icon: 'none'
            });
          }
        }, 5000);
      })
      .catch(err => {
        console.error('[定时] 删除失败:', err);
        wx.hideLoading();
        udpManager.offMessage(messageHandler);
        wx.showToast({
          title: '删除失败',
          icon: 'none'
        });
      });
  },

  // 更新定时
  updateTimer(config) {
    const { udpManager } = getApp().globalData;
    if (!udpManager || !udpManager.isConnected) {
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      return Promise.reject(new Error('设备未连接'));
    }

    const frame = CommandManager.createCommand('UPDATE_TIMER', config);
    return udpManager.send(frame);
  },

  // 阻止事件冒泡
  stopPropagation(e) {
    e.stopPropagation();
  },

  // 触摸开始
  handleTouchStart(e) {
    if (this.data.loading) return;
    
    this.startX = e.touches[0].clientX;
    this.startY = e.touches[0].clientY;
    this.timerId = e.currentTarget.dataset.id;
    this.isSwiping = false; // 标记是否正在滑动
    
    // 获取当前项的索引
    this.itemIndex = this.data.timerList.findIndex(item => item.id === this.timerId);
    
    // 重置其他项的滑动状态
    let timerList = [...this.data.timerList];
    timerList.forEach((item, index) => {
      if (index !== this.itemIndex && item.x !== 0) {
        item.x = 0;
      }
    });
    this.setData({ timerList });
    
    // 记录初始位置的时间戳
    this.startTime = Date.now();
    console.log('[滑动] 开始:', this.timerId);
  },

  // 触摸移动
  handleTouchMove(e) {
    if (!this.startX || this.itemIndex === undefined) return;
    
    const touch = e.touches[0];
    const moveX = touch.clientX - this.startX;
    const moveY = touch.clientY - this.startY;
    
    // 如果水平移动足够多，标记为滑动状态
    if (Math.abs(moveX) > 10) {
      this.isSwiping = true;
    }
    
    // 计算当前位置
    let x = 0;
    if (moveX < 0) {
      // 左滑，最多-150
      x = Math.max(moveX, -150);
    } else {
      // 右滑，如果已经展开就收起
      const currentX = this.data.timerList[this.itemIndex].x || 0;
      if (currentX < 0) {
        x = Math.min(currentX + moveX, 0);
      } else {
        return; // 没展开就不处理右滑
      }
    }
    
    // 更新位置
    let timerList = [...this.data.timerList];
    timerList[this.itemIndex].x = x;
    this.setData({ timerList });
    
    console.log('[滑动] 移动:', x);
  },

  // 触摸结束
  handleTouchEnd(e) {
    if (this.itemIndex === undefined) return;
    
    // 如果水平滑动距离小，可能是点击，不处理滑动逻辑
    const currentX = this.data.timerList[this.itemIndex].x || 0;
    if (Math.abs(currentX) < 10 && !this.isSwiping) {
      // 清理变量但不执行滑动逻辑
      this.startX = null;
      this.startY = null;
      this.timerId = null;
      this.itemIndex = undefined;
      this.startTime = null;
      this.isSwiping = false;
      return;
    }
    
    // 计算滑动速度和位置
    const endTime = Date.now();
    const duration = endTime - this.startTime;
    
    let timerList = [...this.data.timerList];
    
    // 根据滑动距离和速度决定最终位置
    if (currentX < -75 || (currentX < -30 && duration < 200)) {
      // 距离足够大或速度够快，完全展开
      timerList[this.itemIndex].x = -150;
    } else {
      // 否则恢复
      timerList[this.itemIndex].x = 0;
    }
    
    this.setData({ timerList });
    console.log('[滑动] 结束:', timerList[this.itemIndex].x);
    
    // 最后清理临时变量时也清理滑动状态
    this.isSwiping = false;
  },

  // 重置所有滑动
  resetAllSlide() {
    let { timerList } = this.data;
    let changed = false;
    
    timerList = timerList.map(item => {
      if (item.x !== 0) {
        changed = true;
        return { ...item, x: 0 };
      }
      return item;
    });
    
    if (changed) {
      this.setData({ timerList });
    }
  },

  // 添加编辑定时方法
  editTimer(e) {
    // 如果正在滑动状态，则不处理点击
    if (this.isSwiping) return;
    
    const { id } = e.currentTarget.dataset;
    const index = this.data.timerList.findIndex(item => item.id === id);
    
    if (index === -1) {
      wx.showToast({
        title: '定时器不存在',
        icon: 'none'
      });
      return;
    }
    
    const timer = this.data.timerList[index];
    
    // 检查设备连接状态
    const app = getApp();
    const udpManager = app.globalData?.udpManager || sharedUdpManager;
    
    if (!udpManager || !udpManager.isConnected) {
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      return;
    }
    
    console.log('[定时] 编辑定时:', timer);
    
    // 跳转到添加/编辑页面
    wx.navigateTo({
      url: '/pages/timer/add/add?edit=true',
      success: (res) => {
        // 传递定时器数据和UDP管理器
        res.eventChannel.emit('editTimer', {
          timer: timer,
          udpManager: udpManager
        });
      },
      fail: (err) => {
        console.error('[定时] 跳转失败:', err);
        wx.showToast({
          title: '跳转失败',
          icon: 'none'
        });
      }
    });
  }
})